{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Computing Probabilities Using Python\n",
    "## 1.1. Sample Space Analysis: An Equation-Free Approach for Measuring Uncertainty in Outcomes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A coin-flip will produce one of 2 measurable outcomes: _Heads_ or _Tails_. By storing outcomes in a Python set, we can create a **sample space** of coin-flips.\n",
    "\n",
    "**Listing 1. 1. Creating a Sample Space of Coin-Flips**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_space = {'Heads', 'Tails'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All outcomes within `sample_space` share an identical probability, which is equal to `1 / len(sample_space)`.\n",
    "\n",
    "**Listing 1. 2. Computing the probability of heads**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "probability_heads = 1 / len(sample_space)\n",
    "print(f'Probability of choosing heads is {probability_heads}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The probability of choosing `'Heads'` equals 0.5. What is the probability that the coin lands on either heads or on\n",
    "tails? To find rigorous answers, we’ll need to define the\n",
    "concept of an **event**. An event is the subset of those elements within sample_space that\n",
    "satisfy some event condition. An **event condition** is a simple Boolean function whose input\n",
    "is a single sample_space element. \n",
    "\n",
    "**Listing 1. 3. Defining event conditions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_heads_or_tails(outcome):  return outcome in {'Heads', 'Tails'}\n",
    "def is_neither(outcome): return not is_heads_or_tails(outcome)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, for completeness-sake, lets define event conditions for the two basic events in which the coin satisfies exactly one of our two potential outcomes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Listing 1. 4. Defining additional event conditions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_heads(outcome): return outcome == 'Heads'\n",
    "def is_tails(outcome): return outcome == 'Tails'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can pass event conditions into a generalized `get_matching_event` function. The\n",
    "function iterates through `generic_sample_space` and returns the set of outcomes where\n",
    "`event_condition(outcome)` is `True`.\n",
    "\n",
    "**Listing 1. 5. Defining an event detection function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_matching_event(event_condition, generic_sample_space):\n",
    "    return set([outcome for outcome in generic_sample_space \n",
    "                if event_condition(outcome)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets execute `get_matching_event` on our 4 event conditions.\n",
    "\n",
    "**Listing 1. 6. Detecting events using event conditions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Event Condition: is_heads_or_tails\n",
      "Event: {'Tails', 'Heads'}\n",
      "\n",
      "Event Condition: is_heads\n",
      "Event: {'Heads'}\n",
      "\n",
      "Event Condition: is_tails\n",
      "Event: {'Tails'}\n",
      "\n",
      "Event Condition: is_neither\n",
      "Event: set()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "event_conditions = [is_heads_or_tails, is_heads, is_tails, is_neither]\n",
    "\n",
    "for event_condition in event_conditions: \n",
    "    print(f\"Event Condition: {event_condition.__name__}\")\n",
    "    event = get_matching_event(event_condition, sample_space)\n",
    "    print(f'Event: {event}\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We’ve successfully extracted 4 events from `sample_space`. The probability of each event is equal to `len(event) / len(sample_space)`.\n",
    "\n",
    "**Listing 1. 7. Computing event probabilities**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of event arising from 'is_heads_or_tails' is 1.0\n",
      "Probability of event arising from 'is_heads' is 0.5\n",
      "Probability of event arising from 'is_tails' is 0.5\n",
      "Probability of event arising from 'is_neither' is 0.0\n"
     ]
    }
   ],
   "source": [
    "def compute_probability(event_condition, generic_sample_space):\n",
    "    event = get_matching_event(event_condition, generic_sample_space)\n",
    "    return len(event) / len(generic_sample_space)\n",
    "\n",
    "for event_condition in event_conditions: \n",
    "    prob = compute_probability(event_condition, sample_space)\n",
    "    name = event_condition.__name__\n",
    "    print(f\"Probability of event arising from '{name}' is {prob}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1.1. Analyzing a Biased Coin\n",
    "Suppose a coin is 4 times more likely to land on heads relative to tails. We can represent that coin as a weighted sample space.\n",
    "\n",
    "**Listing 1. 8. Representing a weighted sample space**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "weighted_sample_space = {'Heads': 4, 'Tails': 1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our new sample space is stored within a dictionary. We can redefine sample-space size as the sum of all dictionary weights.\n",
    "\n",
    "**Listing 1. 9. Checking the weighted sample space size**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_space_size = sum(weighted_sample_space.values())\n",
    "assert sample_space_size == 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can redefine event size in similar manner. Each event is a set of outcomes. These outcomes map to weights. Summing over these weights will yield the event size.\n",
    "\n",
    "**Listing 1. 10. Checking the weighted event size**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "event = get_matching_event(is_heads_or_tails, weighted_sample_space)\n",
    "event_size = sum(weighted_sample_space[outcome] for outcome in event)\n",
    "assert event_size == 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our generalized definitions of sample-space size and event size permit us to create a\n",
    "`compute_event_probability function.`\n",
    "\n",
    "**Listing 1. 11. Defining a generalized event probability function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_event_probability(event_condition, generic_sample_space):\n",
    "    event = get_matching_event(event_condition, generic_sample_space)\n",
    "    if type(generic_sample_space) == type(set()):\n",
    "        return len(event) / len(generic_sample_space)\n",
    "    \n",
    "    event_size = sum(generic_sample_space[outcome] \n",
    "                     for outcome in event)\n",
    "    return event_size / sum(generic_sample_space.values())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now output all the event probabilities for the biased coin without needing to redefine our 4 event condition functions.\n",
    "\n",
    "**Listing 1. 12. Computing weighted event probabilities**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of event arising from 'is_heads_or_tails' is 1.0\n",
      "Probability of event arising from 'is_heads' is 0.8\n",
      "Probability of event arising from 'is_tails' is 0.2\n",
      "Probability of event arising from 'is_neither' is 0.0\n"
     ]
    }
   ],
   "source": [
    "for event_condition in event_conditions: \n",
    "    prob = compute_event_probability(event_condition, weighted_sample_space)\n",
    "    name = event_condition.__name__\n",
    "    print(f\"Probability of event arising from '{name}' is {prob}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2. Computing Non-Trivial Probabilities\n",
    "### 1.2.1. Problem 1: Analyzing a Family with Four Children\n",
    "Suppose a family has 4 children. What is the probability that exactly 2 of the children are\n",
    "boys? We’ll find solve this by constructing an unweighted sample space where each outcome is a 4-element tuple\n",
    "representing one possible sequence of 4 children.\n",
    "\n",
    "**Listing 1. 13. Computing the sample space of children**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "possible_children = ['Boy', 'Girl']\n",
    "sample_space = set()\n",
    "for child1 in possible_children:\n",
    "    for child2 in possible_children:\n",
    "        for child3 in possible_children:\n",
    "            for child4 in possible_children:\n",
    "                outcome = (child1, child2, child3, child4)\n",
    "                sample_space.add(outcome)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We ran 4 nested for-loops to explore the sequence of 4 births. This is not an efficient use of\n",
    "code. We can more easily generate our sample space using Python’s build-in `itertools.product` function.\n",
    "\n",
    "**Listing 1. 14. Computing the sample space using `product`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import product\n",
    "all_combinations = product(*(4 * [possible_children]))\n",
    "assert set(all_combinations) == sample_space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make our code even more efficient by executing `set(product(possible_children, repeat=4))`.\n",
    "\n",
    "**Listing 1. 15. Passing `repeat` into `product`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_space_efficient = set(product(possible_children, repeat=4))\n",
    "assert sample_space == sample_space_efficient"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets calculate the fraction of `sample_space` that is composed of families with 2 boys.\n",
    "\n",
    "**Listing 1. 16. Computing the probability of 2 boys**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of 2 boys is 0.375\n"
     ]
    }
   ],
   "source": [
    "def has_two_boys(outcome): return len([child for child in outcome\n",
    "                                      if child == 'Boy']) == 2\n",
    "\n",
    "prob = compute_event_probability(has_two_boys, sample_space)\n",
    "print(f\"Probability of 2 boys is {prob}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.2. Problem 2: Analyzing Multiple Die Rolls\n",
    "Suppose a die is rolled 6 times. What is the probability that these 6 dice-rolls add up to 21? We’ll begin by defining the possible values of any single roll.\n",
    "\n",
    "**Listing 1. 17. Defining all possible rolls of a six-sided die**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "possible_rolls = list(range(1, 7))\n",
    "print(possible_rolls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we’ll create the sample space for 6 consecutive rolls.\n",
    "\n",
    "**Listing 1. 18. The sample space for 6 consecutive die rolls**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_space = set(product(possible_rolls, repeat=6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we’ll define a `has_sum_of_21 event condition` that we’ll subsequently pass into `compute_event_probability`.\n",
    "\n",
    "**Listing 1. 19. Computing the probability of a die-roll sum**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 rolls sum to 21 with a probability of 0.09284979423868313\n"
     ]
    }
   ],
   "source": [
    "def has_sum_of_21(outcome): return sum(outcome) == 21\n",
    "\n",
    "prob = compute_event_probability(has_sum_of_21, sample_space)\n",
    "print(f\"6 rolls sum to 21 with a probability of {prob}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above analysis can be executed in a single line of code, using Lambda expressions.\n",
    "\n",
    "**Listing 1. 20. Computing the probability using a lambda expression**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob = compute_event_probability(lambda x: sum(x) == 21, sample_space) \n",
    "assert prob == compute_event_probability(has_sum_of_21, sample_space)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.3. Problem 3: Computing Die-Roll Probabilities using Weighted Sample Spaces\n",
    "We’ve just computed the likelihood of 6 die-roolls summing to 21. Now, lets recompute\n",
    "that probability using a weighted sample space. By mapping the die-roll sums to their occurrence counts, we will produce a `weighted_sample_space result`.\n",
    "\n",
    "**Listing 1. 21. Mapping die-roll sums to ocurrence counts**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "weighted_sample_space = defaultdict(int)\n",
    "for outcome in sample_space:\n",
    "    total = sum(outcome)\n",
    "    weighted_sample_space[total] += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not all weights in `weighted_sample_space` are equal. Some of the weights are much smaller than others. For instance, there is only one way for the dice to sum to 6.\n",
    "\n",
    "**Listing 1. 22. Checking very rare die-roll combinations**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert weighted_sample_space[6] == 1\n",
    "assert weighted_sample_space[36] == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Meanwhile, the value of `weighted_sample_space[21]` is noticeably higher.\n",
    "\n",
    "**Listing 1. 23. Checking a more common die-roll combination**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 4332 ways for 6 die rolls to sum to 21\n"
     ]
    }
   ],
   "source": [
    "num_combinations = weighted_sample_space[21]\n",
    "print(f\"There are {num_combinations } ways for 6 die rolls to sum to 21\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are 4332 ways for 6 die-rolls to sum to 21. This is why a sum of 21 is much more probable than a sum of 6.\n",
    "\n",
    "**Listing 1. 24. Exploring different ways of summing to 21**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert sum([4, 4, 4, 4, 3, 2]) == 21\n",
    "assert sum([4, 4, 4, 5, 3, 1]) == 21 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The observed count of 4332 is equal to the length of an unweighted event whose die-rolls add up to 21. Hence, there exists a direct link between unweighted and\n",
    "weighted event probability computation.\n",
    "\n",
    "**Listing 1. 25. Comparing weighted events and regular events**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "event = get_matching_event(lambda x: sum(x) == 21, sample_space)\n",
    "assert weighted_sample_space[21] == len(event)\n",
    "assert sum(weighted_sample_space.values()) == len(sample_space)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final probability of rolling a 21 should remain unchanged.\n",
    "\n",
    "**Listing 1. 26. Computing the weighted event probability of die rolls**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 rolls sum to 21 with a probability of 0.09284979423868313\n"
     ]
    }
   ],
   "source": [
    "prob = compute_event_probability(lambda x: x == 21, \n",
    "                                 weighted_sample_space)\n",
    "assert prob == compute_event_probability(has_sum_of_21, sample_space)\n",
    "print(f\"6 rolls sum to 21 with a probability of {prob}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the benefit of using a weighted sample space over an unweighted one? Less\n",
    "memory usage!\n",
    "\n",
    "**Listing 1. 27. Comparing weighted to unweighted event space size**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Elements in Unweighted Sample Space:\n",
      "46656\n",
      "Number of Elements in Weighted Sample Space:\n",
      "31\n"
     ]
    }
   ],
   "source": [
    "print('Number of Elements in Unweighted Sample Space:')\n",
    "print(len(sample_space))\n",
    "print('Number of Elements in Weighted Sample Space:')\n",
    "print(len(weighted_sample_space))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3. Computing Probabilities Over Interval Ranges\n",
    "An **interval** is the set of all the numbers that are sandwiched between 2 boundary cutoffs. Lets define an\n",
    "`is_in_interval` function that checks whether a number falls within a specified interval.\n",
    "\n",
    "**Listing 1. 28. Defining an interval function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_in_interval(number, minimum, maximum):\n",
    "    return minimum <= number <= maximum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given the `is_in_interval` function, we can compute the probability that an event’s\n",
    "associated value falls within some numeric range. Let’s compute the likelihood\n",
    "that our 6 consecutive die-rolls sum up to a value between 10 and 21.\n",
    "\n",
    "**Listing 1. 29. Computing the probability over an interval**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of interval is 0.5446244855967078\n"
     ]
    }
   ],
   "source": [
    "prob = compute_event_probability(lambda x: is_in_interval(x, 10, 21), \n",
    "                                 weighted_sample_space)\n",
    "print(f\"Probability of interval is {prob}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3.1. Evaluating Extremes Using Interval Analysis\n",
    "Suppose we observe 10 flips of an allegedly fair coin, and that coin lands on heads 8 out of 10 times. What is the probability that 10 fair coin-flips produce between 8 and 10 heads? To find out, we'll need the sample space for every possible sequence of 10 flipped coins.\n",
    "\n",
    "**Listing 1. 30. Computing the sample space for 10 coin-flips**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_coin_sample_space(num_flips=10): \n",
    "    weighted_sample_space = defaultdict(int)\n",
    "    for coin_flips in product(['Heads', 'Tails'], repeat=num_flips):\n",
    "        heads_count = len([outcome for outcome in coin_flips\n",
    "                          if outcome == 'Heads']) \n",
    "        weighted_sample_space[heads_count] += 1\n",
    "\n",
    "    return weighted_sample_space\n",
    "\n",
    "weighted_sample_space = generate_coin_sample_space()\n",
    "assert weighted_sample_space[10] == 1\n",
    "assert weighted_sample_space[9] == 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We’ll now compute the probability of observing an interval between 8 and 10 heads.\n",
    "\n",
    "**Listing 1. 31. Computing an extreme head-count probability**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of observing more than 7 heads is 0.0546875\n"
     ]
    }
   ],
   "source": [
    "prob = compute_event_probability(lambda x: is_in_interval(x, 8, 10),\n",
    "                                 weighted_sample_space)\n",
    "print(f\"Probability of observing more than 7 heads is {prob}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observing 8 out of 10 tails is as extreme as observing 8 out of 10 heads. What is the probability of observing more than 7 heads or 7 tails?\n",
    "\n",
    "**Listing 1. 32. Computing an extreme interval probability**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of observing more than 7 heads or 7 tails is 0.109375\n"
     ]
    }
   ],
   "source": [
    "prob = compute_event_probability(lambda x: not is_in_interval(x, 3, 7),\n",
    "                                 weighted_sample_space)\n",
    "print(f\"Probability of observing more than 7 heads or 7 tails is {prob}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we flip the coin 10 additional times, and 8 more heads come up. This brings us to 16 heads out of 20 coin-flips. Lets find the probability of 20 fair coin-flips producing more than 15 heads or 15 tails.\n",
    "\n",
    "**Listing 1. 33. Analyzing extreme head-counts for 20 fair coin-flips**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of observing more than 15 heads or 15 tails is 0.01181793212890625\n"
     ]
    }
   ],
   "source": [
    "weighted_sample_space_20_flips = generate_coin_sample_space(num_flips=20)\n",
    "prob = compute_event_probability(lambda x: not is_in_interval(x, 5, 15),\n",
    "                                 weighted_sample_space_20_flips)\n",
    "print(f\"Probability of observing more than 15 heads or 15 tails is {prob}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 Plotting Probabilities Using Matplotlib\n",
    "## 2.1. Basic Matplotlib Plots\n",
    "Lets import the Matplotlib plotting library.\n",
    "\n",
    "**Listing 2. 1. Importing Matplotlib**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now plot some linear data using `plt.plot`. \n",
    "\n",
    "**Listing 2. 2. Plotting a linear relationship**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = range(0, 10)\n",
    "y = [2 * value for value in x]\n",
    "plt.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our plotted points have been connected using smooth line segments. We can visualize these points individually using the `plt.scatter` method.\n",
    "\n",
    "**Listing 2. 3. Plotting individual data-points**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we want to emphasize the interval where x begins at 2 and ends at 6. We do this by shading the area under the plotted curve over the specified interval, using the `plt.fill_between` method.\n",
    "\n",
    "**Listing 2. 4. Shading an interval beneath a connected plot.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, y)\n",
    "where = [is_in_interval(value, 2, 6) for value in x]\n",
    "plt.fill_between(x, y, where=where)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets highlight an interval beneath a continuous line while also exposing individual coordinates.\n",
    "\n",
    "**Listing 2. 5. Exposing individual coordinates within a continuous plot**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x, y)\n",
    "plt.plot(x, y)\n",
    "plt.fill_between(x, y, where=where)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No data plot is ever truly complete without descriptive x-axis and y-axis labels. Such labels can be set using the `plt.xlabel` and `plt.ylabel` methods.\n",
    "\n",
    "**Listing 2. 6. Adding axes labels.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, y)\n",
    "plt.xlabel('Values between zero and ten')\n",
    "plt.ylabel('Twice the values of x')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2. Plotting Coin-Flip Probabilities\n",
    "\n",
    "Our aim is to compare the plotted data from `weighted_sample_space` and `weighted_sample_space_20_flips`. We will begin plotting the elements of `weighted_sample_space`. The x-axis will correspond to `'Head-count'`. The y-axis\n",
    "will correspond to `'Number of coin-flip combinations with x heads'`.\n",
    "\n",
    "**Listing 2. 7. Plotting the coin-flip weighted sample space**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_10_flips = list(weighted_sample_space.keys())\n",
    "y_10_flips = [weighted_sample_space[key] for key in x_10_flips]\n",
    "plt.scatter(x_10_flips, y_10_flips)\n",
    "plt.xlabel('Head-count')\n",
    "plt.ylabel('Number of coin-flip combinations with x heads')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets plot the probabilities directly on the y-axis. The probability plot will allow us to replace our lengthy y-axis label with a more concisely stated `'Probability'`.\n",
    "\n",
    "**Listing 2. 8. Plotting the coin-flip probabilities**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sample_space_size = sum(weighted_sample_space.values())\n",
    "prob_x_10_flips = [value / sample_space_size for value in y_10_flips]\n",
    "plt.scatter(x_10_flips, prob_x_10_flips)\n",
    "plt.xlabel('Head-count')\n",
    "plt.ylabel('Probability')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mapping between x-values and probabilities is called a **probability distribution**. The total area beneath a\n",
    "probability distribution always equals 1.0.\n",
    "\n",
    "**Listing 2. 9. Confirming that all probabilities sum to 1.0**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert sum(prob_x_10_flips) == 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The area beneath the head-count interval of 8 through 10 is equal to the probability of observing 8 heads or more. We can visualize that area using the `plt.fill_between method`. \n",
    "\n",
    "**Listing 2. 10. Shading the interval under a probability curve**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_10_flips, prob_x_10_flips)\n",
    "plt.scatter(x_10_flips, prob_x_10_flips)\n",
    "where = [is_in_interval(value, 8, 10) for value in x_10_flips]\n",
    "plt.fill_between(x_10_flips, prob_x_10_flips, where=where)\n",
    "plt.xlabel('Head-count')\n",
    "plt.ylabel('Probability')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, lets also the shade the interval demarcating the probability of observing 8 tails or more.\n",
    "\n",
    "**Listing 2. 11. Shading the interval under the extremes of a probability curve**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_10_flips, prob_x_10_flips)\n",
    "plt.scatter(x_10_flips, prob_x_10_flips)\n",
    "where = [not is_in_interval(value, 3, 7) for value in x_10_flips]\n",
    "plt.fill_between(x_10_flips, prob_x_10_flips, where=where)\n",
    "plt.xlabel('Head-count')\n",
    "plt.ylabel('Probability')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The two symmetrically shaded intervals cover the right and left tail-ends of the coin-flip curve.\n",
    "\n",
    "### 2.2.1. Comparing Multiple Coin-Flip Probability Distributions\n",
    "Lets extend our plot to also encompass the distribution for 20 flipped coins. We’ll plot both distributions on a single figure, though first we must compute the x-axis head-counts and y-axis probabilities for the 20 coin-flip distribution.\n",
    "\n",
    "**Listing 2. 12. Computing probabilities for a 20 coin-flip distribution.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_20_flips = list(weighted_sample_space_20_flips.keys())\n",
    "y_20_flips = [weighted_sample_space_20_flips[key] for key in x_20_flips]\n",
    "sample_space_size = sum(weighted_sample_space_20_flips.values())\n",
    "prob_x_20_flips = [value / sample_space_size for value in y_20_flips]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are ready to visualize the 2 distributions simultaneously.\n",
    "\n",
    "**Listing 2. 13. Plotting two simultaneous distributions.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_10_flips, prob_x_10_flips, label='A: 10 coin-flips')\n",
    "plt.scatter(x_10_flips, prob_x_10_flips)\n",
    "plt.plot(x_20_flips, prob_x_20_flips, color='black', linestyle='--',\n",
    "        label='B: 20 coin-flips')\n",
    "plt.scatter(x_20_flips, prob_x_20_flips, color='k', marker='x')\n",
    "plt.xlabel('Head-count')\n",
    "plt.ylabel('Probability')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We’ve visualized our 2 distributions. Next, we’ll proceed to highlight our interval of interest (80% of heads or tails) across each of the 2 plotted curves.\n",
    "\n",
    "**Listing 2. 14. Highlighting intervals beneath two plotted distributions.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_10_flips, prob_x_10_flips, label='A: 10 coin-flips')\n",
    "plt.plot(x_20_flips, prob_x_20_flips, color='k', linestyle=':', \n",
    "         label='B: 20 coin-flips')\n",
    "\n",
    "where_10 = [not is_in_interval(value, 3, 7) for value in x_10_flips]\n",
    "plt.fill_between(x_10_flips, prob_x_10_flips, where=where_10)\n",
    "where_20 = [not is_in_interval(value, 5, 15) for value in x_20_flips]\n",
    "plt.fill_between(x_20_flips, prob_x_20_flips, where=where_20)\n",
    "\n",
    "plt.xlabel('Head-Count')\n",
    "plt.ylabel('Probability')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets improve the visualization by aligning the distribution peaks. If we convert the head-counts into frequencies (by\n",
    "dividing by the total coin flips), then both the distribution peaks should align at a frequency of 0.5.\n",
    "\n",
    "**Listing 2. 15. Converting head-counts into frequencies**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_10_frequencies = [head_count / 10 for head_count in x_10_flips]\n",
    "x_20_frequencies = [head_count / 20 for head_count in x_20_flips]\n",
    "\n",
    "plt.plot(x_10_frequencies, prob_x_10_flips, label='A: 10 coin-flips')\n",
    "plt.plot(x_20_frequencies, prob_x_20_flips, color='k', linestyle=':', label='B: 20 coin-flips')\n",
    "plt.legend()\n",
    "\n",
    "plt.xlabel('Head-Frequency')\n",
    "plt.ylabel('Probability')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 2 peaks now align. However, the total area beneath each curve no longer equals 1.0. We’ll need to force the aligned curve-areas to equal 1.0 prior to doing interval comparison. The adjusted y-values will no longer be probabilities. They will become **relative likelihoods**.\n",
    "\n",
    "**Listing 2. 16. Computing relative likelihoods of frequencies**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "relative_likelihood_10 = [10 * prob for prob in prob_x_10_flips]\n",
    "relative_likelihood_20 = [20 * prob for prob in prob_x_20_flips]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Listing 2. 17. Plotting aligned relative likelihood curves**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_10_frequencies, relative_likelihood_10, label='A: 10 coin-flips')\n",
    "plt.plot(x_20_frequencies, relative_likelihood_20, color='k',\n",
    "         linestyle=':', label='B: 20 coin-flips')\n",
    "\n",
    "plt.fill_between(x_10_frequencies, relative_likelihood_10, where=where_10)\n",
    "plt.fill_between(x_20_frequencies, relative_likelihood_20, where=where_20)\n",
    "\n",
    "plt.legend()\n",
    "plt.xlabel('Head-Frequency')\n",
    "plt.ylabel('Relative Likelihood')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Curve A covers a larger area over more extreme head-frequency intervals. Hence, observed recordings of such frequencies are more likely to occur when the coin-flip count is 10 and not 20."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Running Random Simulations in NumPy\n",
    "## 3.1. Simulating Random Coin-Flips and Die-Rolls Using NumPy\n",
    "Lets import the NumPy numerical computing library.\n",
    "\n",
    "**Listing 3. 1. Importing NumPy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can carry out random simulations using the `np.random` module. Calling `np.random.randint(1, 7)` will simulate a single roll of a standard die.\n",
    "\n",
    "**Listing 3. 2. Simulating a randomly rolled die**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "die_roll = np.random.randint(1, 6)\n",
    "assert 1 <= die_roll <= 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We’ll need a way of ensuring that all our random outputs can be reproduced at home. Conveniently, consistency can easily be maintained by calling `np.random.seed(0)`.\n",
    "\n",
    "**Listing 3. 3. Seeding reproducible random die-rolls**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "die_rolls = [np.random.randint(1, 7) for _ in range(3)]\n",
    "assert die_rolls == [5, 6, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We’ll now use `np.random.randint(0, 2)` to simulate a single flip of an unbiased\n",
    "coin.\n",
    "\n",
    "**Listing 3. 4. Simulating one fair coin-flip**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coin landed on tails\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "coin_flip = np.random.randint(0, 2)\n",
    "print(f\"Coin landed on {'heads' if coin_flip == 1 else 'tails'}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we’ll simulate a sequence of 10 coin-flips, and then compute the observed frequency of heads.\n",
    "\n",
    "**Listing 3. 5. Simulating 10 fair coin-flips**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frequency of Heads is 0.8\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "def frequency_heads(coin_flip_sequence):\n",
    "    total_heads = len([head for head in coin_flip_sequence if head == 1])\n",
    "    return total_heads / len(coin_flip_sequence)\n",
    "\n",
    "coin_flips = [np.random.randint(0, 2) for _ in range(10)]\n",
    "freq_heads = frequency_heads(coin_flips)\n",
    "print(f\"Frequency of Heads is {freq_heads}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets see what happens when we flip the coin 1000 times. After each flip, we will record the total frequency of heads observed in the sequence. Once the coin-flips are completed, we will plot the results.\n",
    "\n",
    "**Listing 3. 6. Plotting simulated fair coin-flip frequencies**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "coin_flips = []\n",
    "frequencies = []\n",
    "for _ in range(1000):\n",
    "    coin_flips.append(np.random.randint(0, 2))\n",
    "    frequencies.append(frequency_heads(coin_flips))\n",
    "\n",
    "plt.plot(list(range(1000)), frequencies)\n",
    "plt.axhline(0.5, color='k')\n",
    "plt.xlabel('Number of Coin Flips')\n",
    "plt.ylabel('Head-Frequency')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The probability of heads slowly converges to 0.5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "### 3.1.1. Analyzing Biased Coin-Flips\n",
    "Lets simulate a coin that falls on heads 70% of the time? We'll generate that biased output by calling `np.random.binomial(1, .7)`.\n",
    "\n",
    "**Listing 3. 7. Simulating biased coin-flips**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lets flip the biased coin once.\n",
      "Biased coin landed on heads.\n",
      "\n",
      "Lets flip the biased coin 10 times.\n",
      "6 heads were observed out of 10 biased coin flips\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "print(\"Lets flip the biased coin once.\")\n",
    "coin_flip = np.random.binomial(1, 0.7)\n",
    "print(f\"Biased coin landed on {'heads' if coin_flip == 1 else 'tails'}.\")\n",
    "\n",
    "print(\"\\nLets flip the biased coin 10 times.\")\n",
    "number_coin_flips = 10\n",
    "head_count = np.random.binomial(number_coin_flips, .7)\n",
    "print((f\"{head_count} heads were observed out of \" \n",
    "       f\"{number_coin_flips} biased coin flips\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets generate a sequence of 1000 biased coin-flips. We’ll then check if the frequency converges to 0.7.\n",
    "\n",
    "**Listing 3. 8. Computing coin-flip frequency convergence**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frequency of Heads is 0.697\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "head_count = np.random.binomial(1000, .7)\n",
    "frequency = head_count / 1000\n",
    "print(f\"Frequency of Heads is {frequency}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The frequency is .03 units smaller than the true probability of heads. Suppose we recompute the frequency of 1000 coin-flips five more times. Will any of the frequencies be equal to 0.7? \n",
    "\n",
    "**Listing 3. 9. Re-computing coin-flip frequency convergence**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frequency at iteration 1 is 0.69\n",
      "Frequency at iteration 2 is 0.7\n",
      "Frequency equals the probability!\n",
      "\n",
      "Frequency at iteration 3 is 0.707\n",
      "Frequency at iteration 4 is 0.702\n",
      "Frequency at iteration 5 is 0.699\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "assert np.random.binomial(1000, 0.7) / 1000 == 0.697\n",
    "for i in range(1, 6):\n",
    "    head_count = np.random.binomial(1000, .7)\n",
    "    frequency = head_count / 1000\n",
    "    print(f\"Frequency at iteration {i} is {frequency}\")\n",
    "    if frequency == 0.7:\n",
    "        print(\"Frequency equals the probability!\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just one out the 5 iterations produced a measurement that equaled the real probability. The observed frequency appears to fluctuate over every sampling of 1000 coin-flips."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2. Computing Confidence Intervals Using Histograms and NumPy Arrays\n",
    "We’ve previously sampled our coin over 5 iterations of 1000 coin-flips each. The sampling produced some fluctuations in the frequency. Lets explore these fluctuations by increasing our frequency count from 5 to 500.\n",
    "\n",
    "**Listing 3. 10. Computing frequencies with 500 flips-per-sample**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "head_count_list = [np.random.binomial(1000, 0.7) for _ in range(500)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can more efficiently sample over 500 iterations by running `np.random.binomial(coin_flip_count, 0.7, size=500)`. \n",
    "\n",
    "**Listing 3. 11. Optimizing the coin-flip frequency computation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "head_count_array = np.random.binomial(1000, 0.7, 500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output is not a Python list, but a NumPy array data-structure. The actual numeric quantities stored\n",
    "with both `head_count_array` and `head_count_list` remain the same.\n",
    "\n",
    "**Listing 3. 12. Converting a NumPy array to a Python list**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert head_count_array.tolist() == head_count_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also convert our Python list into a value-equivalent NumPy array by calling np.array(head_count_list).\n",
    "\n",
    "**Listing 3. 13. Converting a Python list to a NumPy array**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_array = np.array(head_count_list)\n",
    "assert np.array_equal(new_array, head_count_array) == True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dividing a NumPy array by some number will automatically divide all array elements by that number. Thus, executing `head_count_array / 1000` will automatically transform our head-counts into frequencies.\n",
    "\n",
    "**Listing 3. 14. Computing frequencies using NumPy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "frequency_array = head_count_array / 1000\n",
    "assert frequency_array.tolist() == [head_count / 1000\n",
    "                                    for head_count in head_count_list]\n",
    "assert frequency_array.tolist() == list(map(lambda x: x / 1000, \n",
    "                                        head_count_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets explore the contents of `frequency_array` in greater detail. We’ll start by printing the first 20 sampled frequencies within the array.\n",
    "\n",
    "**Listing 3. 15. Printing a NumPy frequency array**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.697 0.69  0.7   0.707 0.702 0.699 0.723 0.67  0.702 0.713 0.721 0.689\n",
      " 0.711 0.697 0.717 0.691 0.731 0.697 0.722 0.728]\n"
     ]
    }
   ],
   "source": [
    "print(frequency_array[:20])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, lets extract the minimum and maximum frequencies values by calling the `frequency_array.min()` and\n",
    "`frequency_array.max()` array methods.\n",
    "\n",
    "**Listing 3. 16. Finding the largest and smallest frequency values**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum frequency observed: 0.656\n",
      "Maximum frequency observed: 0.733\n",
      "Difference across frequency range: 0.07699999999999996\n"
     ]
    }
   ],
   "source": [
    "min_freq = frequency_array.min()\n",
    "max_freq = frequency_array.max()\n",
    "print(f\"Minimum frequency observed: {min_freq}\")\n",
    "print(f\"Maximum frequency observed: {max_freq}\")\n",
    "print(f\"Difference across frequency range: {max_freq - min_freq}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Somewhere between the frequency range of 0.656 to 0.733 lies the true probability of\n",
    "heads. How can we rationally narrow the frequency range? Plotting the data could help.\n",
    "\n",
    "**Listing 3. 17. Plotting measured frequencies**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "frequency_counts = defaultdict(int)\n",
    "for frequency in frequency_array:\n",
    "    frequency_counts[frequency] += 1\n",
    "\n",
    "frequencies = list(frequency_counts.keys())\n",
    "counts = [frequency_counts[freq] for freq in frequencies]\n",
    "plt.scatter(frequencies, counts)\n",
    "plt.xlabel('Frequency')\n",
    "plt.ylabel('Count')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our plot is somewhat flawed, since values that are very close get counted separately. Perhaps instead of treating these values as individual points, we should group such proximate frequencies together."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.1. Binning Similar Points in Histogram Plots\n",
    "\n",
    "We’ll sub-divide our frequency range into N equally spaced bins, and then place all frequency values into one of those bins.  Afterwards, we’ll count the total values in each bin, and visualize the counts using a plot. This type of **histogram** plot can be carried out using the `plt.hist` method.\n",
    "\n",
    "**Listing 3. 18. Plotting a frequency histogram using plt.hist**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(frequency_array, bins='auto', edgecolor='black')\n",
    "plt.xlabel('Binned Frequency')\n",
    "plt.ylabel('Count')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The total count of bins within the plot is not yet known. However, we can obtain that information using `counts`, which is a NumPy array returned by `plt.hist`.\n",
    "\n",
    "**Listing 3. 19. Counting bins in a plotted histogram**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Bins: 16\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "counts, _, _ = plt.hist(frequency_array, bins='auto', \n",
    "                        edgecolor='black')\n",
    "\n",
    "print(f\"Number of Bins: {counts.size}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How wide is each bin? To find out, we'll leverage the `bin_edges` array, which is the second variable\n",
    "returned by `plt.hist`.\n",
    "\n",
    "**Listing 3. 20. Finding the width of bins within a histogram**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bin width: 0.004812499999999997\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "counts, bin_edges, _ = plt.hist(frequency_array, bins='auto',\n",
    "                                edgecolor='black')\n",
    "\n",
    "bin_width = bin_edges[1] - bin_edges[0]\n",
    "assert bin_width == (max_freq - min_freq) / counts.size\n",
    "print(f\"Bin width: {bin_width}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `bin_edges` array can be used in tandem with `counts` to output the element-count and\n",
    "coverage-range for any specified bin. \n",
    "\n",
    "**Listing 3. 21. Getting a bin’s frequency and size**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The bin for frequency range 0.656 - 0.6608125 contains 1 element\n",
      "The bin for frequency range 0.6800625 - 0.684875 contains 20 elements\n"
     ]
    }
   ],
   "source": [
    "def output_bin_coverage(i):\n",
    "    count = int(counts[i])\n",
    "    range_start, range_end = bin_edges[i], bin_edges[i+1]\n",
    "    range_string = f\"{range_start} - {range_end}\"\n",
    "    print((f\"The bin for frequency range {range_string} contains \" \n",
    "           f\"{count} element{'' if count == 1 else 's'}\"))\n",
    "    \n",
    "output_bin_coverage(0)\n",
    "output_bin_coverage(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s compute the count and frequency range for the highest peak within our histogram. Conveniently, NumPy arrays have a built-in `argmax` method, which returns the index of the maximum value within a given array.\n",
    "\n",
    "**Listing 3. 22. Finding the index of an array’s maximum value**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert counts[counts.argmax()] == counts.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus, calling `output_bin_coverage(counts.argmax())` should provide us with the output we’ve requested.\n",
    "\n",
    "**Listing 3. 23. Using `argmax` to return a histogram’s peak**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The bin for frequency range 0.6945 - 0.6993125 contains 72 elements\n"
     ]
    }
   ],
   "source": [
    "output_bin_coverage(counts.argmax())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.2. Deriving Probabilities from Histograms\n",
    "We wish to calculate the likelihood that a randomly measured frequency falls within 0.694 - 0.699. The likelihood of an interval equals its area under a curve, but only when the total plotted area sums up to 1.0. We thus must modify our histogram by transforming the counts into relative likelihoods.\n",
    "\n",
    "**Listing 3. 24. Plotting a histogram’s relative likelihoods**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAXwUlEQVR4nO3de9QddX3v8ffHEDVcxRI1JYQoRbygIObgBY9F8YIWi/dL1YJaU8+CFs9xeVCPVrHnUqyXdlWXy6gosijewAPFLgpFgerBS4IRgli1CBgaISiKFyohfs8fM5HHJ8nOzpM9e+9k3q+19nr2/Pbsmc/ehO8zz29+85tUFZKk/rjXpANIksbLwi9JPWPhl6SesfBLUs9Y+CWpZ3abdIBh7LfffrV06dJJx5CkncqqVatuq6qFs9t3isK/dOlSVq5cOekYkrRTSXLjltrt6pGknrHwS1LPWPglqWcs/JLUMxZ+SeqZzgp/kvsm+VqSbya5Nslpbfv9k1yS5Lvtz327yiBJ2lyXR/y/Ap5aVYcBhwPHJnk88Cbg0qo6GLi0XZYkjUlnhb8aP28X57ePAo4HzmzbzwSe21UGSdLmOu3jTzIvyWrgVuCSqvoq8MCqWgfQ/nzAVt67PMnKJCvXr1/fZUxJ6pVOC39Vbayqw4HFwJFJDt2O966oqmVVtWzhws2uOJamwqLFS0gykseixUsm/XHUE2OZsqGqfpLkMuBY4JYki6pqXZJFNH8NSDulH978Aw489cKRbOvG048byXakbelyVM/CJPdrny8AngZ8G7gAOKFd7QTg/K4ySJI21+UR/yLgzCTzaH7BfLqqLkxyJfDpJK8BbgJe1GEGSdIsnRX+qroaeMwW2n8EHNPVfiVJg3nlriT1jIVfknrGwi9JPWPhl6SesfBLUs9Y+CWpZyz8ktQzFn5J6hkLvyT1jIVfknrGwi9JPWPhl6SesfBLUs9Y+CWpZyz8ktQzFn5J6hkLvyT1jIVfknrGwi9JPWPhl6SesfBLUs9Y+CWpZyz8ktQzFn5J6hkLvyT1jIVfknqms8Kf5IAkX0xyXZJrk5zStr8jyc1JVrePZ3eVQZK0ud063PbdwBuq6qokewGrklzSvva+qnp3h/uWJG1FZ4W/qtYB69rnP0tyHbB/V/uTJA1nLH38SZYCjwG+2jadnOTqJGck2Xcr71meZGWSlevXrx9HTEnqhc4Lf5I9gXOB11fVHcAHgYOAw2n+InjPlt5XVSuqallVLVu4cGHXMSWpNzot/Enm0xT9s6vqPICquqWqNlbVr4EPA0d2mUGS9Nu6HNUT4KPAdVX13hnti2as9jxgTVcZJEmb63JUz1HAK4Frkqxu294CvCzJ4UABNwB/2mEGSdIsXY7q+RKQLbz0j13tU5K0bV65K0k9Y+GXpJ6x8EtSz1j4JalnLPyS1DMWfknqGQu/NC3mzSfJSB6LFi+Z9KfRFOvyAi5J22PjBg489cKRbOrG048byXa0a/KIX5J6xsIvST1j4ZeknrHwS7siTxRrAE/uSrsiTxRrAI/4JalntnrEn+Qamjnzt6iqHt1JIklSpwZ19Wz6++6k9udZ7c+XA7/sLJEkqVNbLfxVdSNAkqOq6qgZL70pyZeBd3YdTpI0esP08e+R5EmbFpI8Ediju0iSpC4NM6rnNcAZSfZpl38CvLqzRJKkTm2z8FfVKuCwJHsDqaqfdh9LktSVbXb1JNknyXuBLwCXJnnPjKN/aSwWLV7iBUnSiAzT1XMGsAZ4cbv8SuBjwPO7CiXN9sObf+AFSdKIDFP4D6qqF8xYPi3J6o7ySJI6Nsyonjtnjeo5Crizu0hSx0Y4j420MxrmiP+/AGe2/foBfgyc0GkqqUvOY6OeG2ZUz2ruGdVDVd0xzIaTHAB8AngQ8GtgRVX9bZL7A58ClgI3AC+uqtvnEl6StP22d1TPF7ZjVM/dwBuq6uHA44GTkjwCeBNwaVUdDFzaLkuaVk7xvMvpbFRPVa0D1rXPf5bkOmB/4Hjg6Ha1M4HLgFO3M7ekcbFrbJczllE9SZYCjwG+Cjyw/aVAVa1L8oCtvGc5sBxgyRKPEiRpVDof1ZNkT+Bc4PXDnh8AqKoVVbWsqpYtXLhw2LdJkrZhmCP+1wGfmDWq58RhNp5kPk3RP7uqzmubb0myqD3aXwTcuv2xJUlzNcyonm8yt1E9AT4KXFdV753x0gU0w0H/qv15/vaGliTN3TYLf5L7AC+gGX6526aLVqpqW/PxH0VzIviaGecE3kJT8D+d5DXATcCL5hJckjQ3w3T1nA/8FFgF/GrYDVfVl2i6hrbkmGG3I0karWEK/+KqOrbzJJKksRhmVM//S/KozpNIksZiq0f8Sa4Bql3nVUmup+nqCVBV9ejxRJQkjdKgrh4vsZOkXdCgwn97Vd3RTqomSdpFDCr8f09z1L+Kpstn5gidAh7SYS5JUke2Wvir6rj254PHF0eS1LVBJ3ePGPTGqrpq9HEkSV0b1NXzngGvFfDUEWeRJI3BoK6ep4wziCRpPIa5A9fuSd6aZEW7fHASh3pK0k5qmCt3PwbcBTyxXV4L/M/OEkmSOjVM4T+oqt4FbACoqjvZ+uRrkqQpN0zhvyvJApoTuiQ5iO2YpVOSNF2GmZ3z7cBFwAFJzqaZZ//ELkNJkrozTOFfBTwfeDxNF88pwF5dhpIkdWeYrp5/ADZU1eer6kJgYdsmSdoJDVP4/zfwD0n2SPJY4LPAK7qNJUnqyjA3W/98kvnAJTRdPM+tqu92nkyS1IlBc/X8He1IntbewPXAnyWhqv6863CSpNEbdMS/ctbyqi6DSJLGY9BcPWeOM4ikHpg3n2Q0138+aP8DWLf2ppFsq28GdfV8uqpePOPeu7/Fe+5K2m4bN3DgqReOZFM3nu6UYXM1qKvnlPan364k7UIGdfWsa3/eOPu1JF+muYJXkrSTGWYc/5YsGWkKSdLYzLXwb9bnP1uSM5LcmmTNjLZ3JLk5yer28ew57l+SNEeDTu4+f2svAQuG2PbHgfcDn5jV/r6qevdQ6SRJIzfo5O5zBry2zdPyVXVFkqXbnUiS1KlBJ3df1dE+T07yxzQXiL2hqm7f0kpJlgPLAZYs8ZSCJI3KXPv45+qDwEHA4cA64D1bW7GqVlTVsqpatnDhwjHFk6Rd31gLf1XdUlUbq+rXwIeBI8e5f0nSmAt/kkUzFp8HrNnaupKkbmxzWuYkuwNvAJZU1WuTHAwc0t6UZdD7zgGOBvZLspbmFo5HJzmcZjjoDcCf7lB6SdJ2G+bWix+jmZnzCe3yWuAzbGNkT1W9bAvNH92udJKkkRumq+egqnoXsAGgqu6kGcsvSdoJDVP470qygPZq3SQHAb/qNJUkqTPDdPW8A7gIOCDJ2TSTs53YYSZJUoeGuefuxUlWAY+n6eI5papu6zyZJKkTw4zquQA4B7igqn7RfSRJUpeG6eN/D/CfgW8l+UySFya5b8e5JEkdGaar53Lg8iTzgKcCrwXOAPbuOJskqQPDnNylHdXzHOAlwBGAN2KXpJ3UMH38nwIeRzOy5wPAZe1cO5KkndCwV+7+UVVt7DqMJKl7g+7A9dSq+gKwO3B88tsX61bVeR1nkyR1YNAR/+8DX2DLd+IqwMIvSTuhQXfgenv79J1V9f2ZryV5cKepJEmdGWYc/7lbaPvsqINIksZjUB//w4BHAvskef6Ml/YGvIBL0mTNm8/sc49z9aD9D2Dd2ptGsq2dwaA+/kOA44D78dv9/D+juYhLkiZn4wYOPHXgbUGGduPpx41kOzuLQX385wPnJ3lCVV05xkySpA4NM47/G0lOoun2+U0XT1W9urNUkqTODHNy9yzgQcAzgcuBxTTdPZKkndAwhf/3quptwC+q6kzgD4BHdRtLktSVYQr/hvbnT5IcCuwDLO0skSSpU8P08a9Isi/wNuACYE/gLzpNJUnqzDDz8X+kfXo58JBu40iSujboAq7/NuiNVfXe0ceRJHVt0BH/XmNLIUkam0EXcJ22IxtOcgbNlb+3VtWhbdv9gU/RnBy+AXhxVd2+I/uRJG2fbY7qSfLQJJcmWdMuPzrJW4fY9seBY2e1vQm4tKoOBi5tlyVJYzTMcM4PA2+mHdZZVVcDL93Wm6rqCuDHs5qP55779Z4JPHfYoJKk0Rim8O9eVV+b1Xb3HPf3wKpaB9D+fMActyNJmqNhCv9tSQ6iuesWSV4IrOs0VbOf5UlWJlm5fv36rnen1qLFS0gykseixUsm/XEkbcEwF3CdBKwAHpbkZuD7wMvnuL9bkiyqqnVJFgG3bm3FqlrR7pdly5bVHPen7fTDm3/gVLfSLm6bR/xVdX1VPQ1YCDwMOBp40hz3dwFwQvv8BOD8OW5HkjRHWy38SfZO8uYk70/ydOCXNMX6e8CLt7XhJOcAVwKHJFmb5DXAXwFPT/Jd4OntsiRpjAZ19ZwF3E5TvF8L/Hfg3sBzq2r1tjZcVS/bykvHbGdGSdIIDSr8D6mqRwEk+QhwG7CkqpyLX5J2YoP6+DdNx0xVbQS+b9GXpJ3foCP+w5Lc0T4PsKBdDlBVtXfn6SRJIzdorp554wwiSRqPYS7gkiTtQiz8ktQzw1y5K83NvPkkmXQKSbNY+NWdjRuc/kGaQnb1SFLPWPglqWcs/JLUMxZ+SeoZC78k9YyFX5J6xsIvST1j4d8FjPI+uZJ2fV7AtQvwPrmStodH/JLUMxZ+SWrnlRrVY9HiJZP+RAPZ1SNJI5xXCqa/y9QjfknqGQu/JPWMhV+SesbCL0k9Y+GXpJ6x8EtSz0xkOGeSG4CfARuBu6tq2SRySFIfTXIc/1Oq6rYJ7l+SesmuHknqmUkV/gIuTrIqyfItrZBkeZKVSVauX79+zPEkadc1qcJ/VFUdATwLOCnJk2evUFUrqmpZVS1buHDh+BNK0i5qIoW/qv69/Xkr8DngyEnkkKQ+GnvhT7JHkr02PQeeAawZd45J8+YpkiZlEqN6Hgh8ri1YuwF/X1UXTSDHRHnzFEmTMvbCX1XXA4eNe7+SpIbDOSVp1EZ4Y5cuburijVgkadRGeGOXLrpyPeKXpJ6x8EtSz1j4JalnLPyS1DMWfknqGQu/JPWMhV+SesbCL0k9Y+GXpJ6x8EtSz1j4JalnLPyS1DMWfknqGQu/JPWMhV+SesbCL0k9Y+GXpJ6x8EtSz1j4JalnLPyS1DMWfknqGQu/JPWMhV+SesbCL0k9M5HCn+TYJP+a5HtJ3tTlvhYtXkKSkTx2u8+CkW1LkiZlt3HvMMk84APA04G1wNeTXFBV3+pifz+8+QcceOqFI9nWjacfN9JtSdIkTOKI/0jge1V1fVXdBXwSOH4COSSpl1JV491h8kLg2Kr6k3b5lcDjqurkWestB5a3i4cA/zrWoPfYD7htQvsexjTnm+ZsMN35pjkbTHe+ac4G4813YFUtnN049q4eYEsd3Jv99qmqFcCK7uMMlmRlVS2bdI6tmeZ805wNpjvfNGeD6c43zdlgOvJNoqtnLXDAjOXFwL9PIIck9dIkCv/XgYOTPDjJvYGXAhdMIIck9dLYu3qq6u4kJwP/BMwDzqiqa8edYztMvLtpG6Y53zRng+nON83ZYLrzTXM2mIJ8Yz+5K0maLK/claSesfBLUs/0tvAPM21EkqOTrE5ybZLLZ7TfL8lnk3w7yXVJnjAt+ZIc0rZtetyR5PXTkK1t/69t25ok5yS57yizjSDfKW22a0f9vQ2bL8kbZ/z3W5NkY5L7D/vZJpjtjCS3Jlkz6lw7mi/JAUm+2P7/em2SU6Yo232TfC3JN9tsp40622aqqncPmpPK/wY8BLg38E3gEbPWuR/wLWBJu/yAGa+dCfxJ+/zewP2mKd+s7fyQ5iKOiWcD9ge+Dyxolz8NnDgt3x1wKLAG2J1m4MM/AwePO9+s9Z8DfGEu7x1ntnb5ycARwJpRfmcj+u4WAUe0z/cCvjMt3x3NtU17ts/nA18FHt/Fd7jp0dcj/mGmjfgj4Lyqugmgqm4FSLI3zT/wj7btd1XVT6Yl3yzHAP9WVTdOUbbdgAVJdqMpsKO+hmNH8j0c+EpV/bKq7gYuB543gXwzvQw4Z47vHWc2quoK4McjzDOyfFW1rqquap//DLiO5kBkGrJVVf28bZ/fPjodddPXwr8/8IMZy2vZ/B/BQ4F9k1yWZFWSP27bHwKsBz6W5BtJPpJkjynKN9NLmfE/5qSzVdXNwLuBm4B1wE+r6uJpyUdztP/kJL+TZHfg2fz2xYbjygdAm+FY4Nztfe8Eso3DSPIlWQo8hubIeiqyJZmXZDVwK3BJVY0y22b6WviHmTZiN+CxwB8AzwTeluShbfsRwAer6jHAL4BR97XuSL5mA83FcX8IfGZasiXZl+Yo6MHA7wJ7JHnFtOSrquuA04FLgIto/ly/ewL5NnkO8OWq2nQUvT3vnYsdyTYOO5wvyZ40Bff1VXXHtGSrqo1VdTjNTAZHJjl0hNk209fCP8y0EWuBi6rqF1V1G3AFcFjbvnbGb+TP0vwimJZ8mzwLuKqqbpmibE8Dvl9V66tqA3Ae8MQpykdVfbSqjqiqJ9N0W3x3Avk2mf0XW9fTnexItnHYoXxJ5tMU/bOr6rxpyrZJ2218Gc1fBN3p8gTCtD5ojviupzny3HQi5pGz1nk4cGm77u403QCHtq/9C3BI+/wdwF9PU7729U8Cr5qm7w54HHBt2xaak+R/Ni352tc2nehdAnwb2Hfc+dr19qH5xbPH9r53EtlmvLaU7k7u7sh3F+ATwN9MYbaFtANEgAVtfTmui5y/2WeXG5/mB03/7XdozsT/j7btdcDrZqzzRprRH2to/jTc1H44sBK4Gvi/oy4OI8i3O/AjYJ8p/O5OawvqGuAs4D5Tlu9f2vZvAsdM8Ps7EfjkMO+domzn0Jy72UBzBPyaackHPImm6+VqYHX7ePaUZHs08I022xrgL7r4dzfz4ZQNktQzfe3jl6TesvBLUs9Y+CWpZyz8ktQzFn5J6hkLv6ZKO2Ph6namwquSPLFt/90knx3D/m9Ist9W2q+ZMbviqC88k8bG4ZyaKkl+XlV7ts+fCbylqn5/jPu/AVhWzRW922yf8fq8qtrYfUJpx3nEr2m2N3A7NBNrbZrnPcmJSc5LclGS7yZ516Y3JPl5kv/V/sXwlSQPbNsXJjk3ydfbx1Ft++8kubidcO9DbHnOlS1q9/XOJF8FnpDkFe286quTfCjJvHa9VyX5TpLLk3w4yfvb9o8neeHM7c14/sY259Wb5mdvv4Pr2m1c2+Ze0L72e0n+ecZfSgclOSvJ8TO2eXaSP9zu/wra5Vj4NW0WtIXz28BHgL/cynqHAy8BHgW8JMmmeVL2oJla+TCaOXhe27b/LfC+qvpPwAvabQO8HfhSNRPuXUAzVcPWfLHNtmmepj1opid4HM2V0i8Bjqpmsq2NwMuTLKK5Wvko4OnAI7b1BSR5BnAwzVS/hwOPTfLk9uWDgQ9U1SOBn7SfBeDstv0wmvmP1rWf8VXtNvdp2/9xW/vXrm+3SQeQZrmzLZykubPZJ7YyU+GlVfXTdr1vAQfSTIt7F3Bhu84qmmILzQRxj0h+c0C/d5K9aO6t8HyAqvp8ktsHZHvKrK6ejdwzte4xNDN+fr3dxwKaKXYfB1xWVevbrJ+imRZ6kGe0j2+0y3vSFPybaCa5Wz3j8y1tP8f+VfW59nP8R/v65Uk+kOQB7Wc8t5r7DKjnLPyaWlV1ZXuideEWXv7VjOcbueff8oa658TVzPZ7AU+oqjtnbqQt0nM90fUfM/r1A5xZVW+etf3nDtj+3W0u0gS594xt/Z+q+tCsbS1l88+9gMHdU2cBL6eZEfLVgz+O+sKuHk2tJA+juaXdj0awuYuBk2ds+/D26RU0hZEkzwL2neP2LwVe2B5dk+ZeqgfS3Ozj6PZcwnzgRTPecwPNXwnQ3Kdgfvv8n4BXt3PHk2T/TdvdkmrmlV/b/pIhyX3S3OwD4OPA69v1rp3jZ9MuxiN+TZsFae5EBM2R7AlVtXFGF81c/TnwgSRX0/y7v4Jm5sTTgHOSXEVzq8Wb5rLxqvpWkrcCFye5F80MlSdV1VeSvAO4kqbf/SqaX2YAHwbOT/I1ml8cv2i3dXGShwNXtp/758AraI7wt+aVwIeSvLPd94uA66vqliTX0cwiKwEO55TGKsmJNMNCT97WuiPa3+7ANTQ3Gv/pOPap6WdXj7SLSvI0mnsf/J1FXzN5xC9JPeMRvyT1jIVfknrGwi9JPWPhl6SesfBLUs/8f7tJH7wk7O7pAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "likelihoods, bin_edges, _ = plt.hist(frequency_array, bins='auto', edgecolor='black', density=True)\n",
    "plt.xlabel('Binned Frequency')\n",
    "plt.ylabel('Relative Likelihood')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The total area beneath our histogram now sums to 1.0.\n",
    "\n",
    "**Listing 3. 25. Computing the total area under a histogram**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert likelihoods.sum() * bin_width == 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus, the area beneath the histogram’s peak is now a probability. We can compute that probability by calculating the area of the bin positioned at `likelihoods.argmax()`.\n",
    "\n",
    "**Listing 3. 26. Computing the probability of the peak frequencies**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sampled frequency falls within interval 0.6945 - 0.6993125 with probability 0.144\n"
     ]
    }
   ],
   "source": [
    "index = likelihoods.argmax()\n",
    "area = likelihoods[index] * bin_width\n",
    "range_start, range_end = bin_edges[index], bin_edges[index+1]\n",
    "range_string = f\"{range_start} - {range_end}\"\n",
    "print(f\"Sampled frequency falls within interval {range_string} with probability {area}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The probability is low, but we can raise it by expanding our interval range beyond one bin. We’ll stretch the range to cover neighboring bins at `indices likelihoods.argmax() - 1` and `likelihoods.argmax() + 1`.\n",
    "\n",
    "**Listing 3. 27. Raising the probability of a frequency range**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sampled frequency falls within interval 0.6896875 - 0.704125 with probability 0.464\n"
     ]
    }
   ],
   "source": [
    "peak_index = likelihoods.argmax()\n",
    "start_index, end_index = (peak_index - 1, peak_index + 2)\n",
    "area = likelihoods[start_index: end_index + 1].sum() * bin_width\n",
    "range_start, range_end = bin_edges[start_index], bin_edges[end_index]\n",
    "range_string = f\"{range_start} - {range_end}\"\n",
    "print(f\"Sampled frequency falls within interval {range_string} with probability {area}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These three bins represent what statisticians call a 46.4% **confidence interval**. Ideally, we’d prefer a confidence interval of 95% or more. We’ll reach that confidence interval by iteratively expanding our left-most bin and right-most bin until the interval area stretches past 0.95.\n",
    "\n",
    "**Listing 3. 28. Computing a high confidence interval**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The frequency range 0.670438 - 0.723375 represents a 95.40% confidence interval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(3, 14)"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compute_high_confidence_interval(likelihoods, bin_width):\n",
    "    peak_index = likelihoods.argmax()\n",
    "    area = likelihoods[peak_index] * bin_width\n",
    "    start_index, end_index = peak_index, peak_index + 1\n",
    "    while area < 0.95:\n",
    "        if start_index > 0:\n",
    "            start_index -= 1\n",
    "        if end_index < likelihoods.size - 1:\n",
    "            end_index += 1\n",
    "\n",
    "        area = likelihoods[start_index: end_index + 1].sum() * bin_width\n",
    "    \n",
    "    range_start, range_end = bin_edges[start_index], bin_edges[end_index]\n",
    "    range_string = f\"{range_start:.6f} - {range_end:.6f}\"\n",
    "    print((f\"The frequency range {range_string} represents a \"\n",
    "           f\"{100 * area:.2f}% confidence interval\"))\n",
    "    return start_index, end_index\n",
    "\n",
    "compute_high_confidence_interval(likelihoods, bin_width)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From our analysis, we’re fairly confident that the true probability lies somewhere between 0.670 and 0.723."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.3. Shrinking the Range of a High Confidence Interval\n",
    "How can we taper down our range while still maintaining a 95% confidence interval? Perhaps we should try elevating the frequency count from 500 to 100,000.\n",
    "\n",
    "**Listing 3. 29. Sampling 100,000 frequencies**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "head_count_array = np.random.binomial(1000, 0.7, 100000)\n",
    "frequency_array = head_count_array / 1000\n",
    "assert frequency_array.size == 100000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will re-compute the histogram on the updated `frequency_array`. Afterwards, we’ll visualize that histogram while also searching for a high confidence interval. Lets incorporate the confidence interval into our visualization by coloring the histogram bars within its range.\n",
    "\n",
    "**Listing 3. 30. Coloring histogram bars over an interval**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The frequency range 0.670429 - 0.727857 represents a 95.42% confidence interval\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "likelihoods, bin_edges, patches = plt.hist(frequency_array, bins='auto', \n",
    "                                           edgecolor='black', density=True)\n",
    "bin_width = bin_edges[1] - bin_edges[0]\n",
    "start_index, end_index = compute_high_confidence_interval(likelihoods, \n",
    "                                                          bin_width)\n",
    "\n",
    "for i in range(start_index, end_index):\n",
    "     patches[i].set_facecolor('yellow')\n",
    "plt.xlabel('Binned Frequency')\n",
    "plt.ylabel('Relative Likelihood')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The new frequency range is nearly identical to the one we saw before. Raising the sampling size\n",
    "from 500 to 100,000 appears to have done little to reduce the range. Perhaps we should’ve also raised the number of coin-flips per frequency-sample.  Lets increase this value 50-fold to 50,000 coin-flips per sampled frequency.\n",
    "\n",
    "**Listing 3. 31. Sampling 5 billion flipped coins**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The frequency range 0.695769 - 0.703708 represents a 95.06% confidence interval\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "head_count_array = np.random.binomial(50000, 0.7, 100000)\n",
    "frequency_array = head_count_array / 50000\n",
    "\n",
    "likelihoods, bin_edges, patches = plt.hist(frequency_array, bins='auto',\n",
    "                                           edgecolor='black', density=True)\n",
    "bin_width = bin_edges[1] - bin_edges[0]\n",
    "start_index, end_index = compute_high_confidence_interval(likelihoods, bin_width)\n",
    "\n",
    "for i in range(start_index, end_index):\n",
    "     patches[i].set_facecolor('yellow')\n",
    "plt.xlabel('Binned Frequency')\n",
    "plt.ylabel('Relative Likelihood')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The new 95.06% confidence interval covers a frequency range of roughly 0.695 - 0.703. We are thus exceedingly confident that our true probability is approximately 0.70."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.4. Computing Histograms in NumPy\n",
    "Calling the `plt.hist` method will automatically generate a histogram plot. Can we obtain the histogram likelihoods and bin-edges without creating a plot? Yes; we simply need to call `np.histogram.`\n",
    "\n",
    "**Listing 3. 32. Computing a histogram using `np.histogram`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The frequency range 0.695769 - 0.703708 represents a 95.06% confidence interval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(47, 114)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "\n",
    "likelihoods, bin_edges = np.histogram(frequency_array, bins='auto',\n",
    "                                      density=True)\n",
    "bin_width = bin_edges[1] - bin_edges[0]\n",
    "compute_high_confidence_interval(likelihoods, bin_width)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3. Leveraging Confidence Intervals to Analyze a Biased Deck of Cards\n",
    "Lets model a deck containing a hidden quantity of red cards. The total size of that deck is 52. The number of red cards in the deck is some unknown integer between zero and 52. We'll generate that integer using the `np.random.randint` method.\n",
    "\n",
    "**Listing 3. 33. Generating a random red card count**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "total_cards = 52\n",
    "red_card_count = np.random.randint(0, total_cards + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets assign a value to `black_card_count`.\n",
    "\n",
    "**Listing 3. 34. Generating a black card count**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "black_card_count = total_cards - red_card_count\n",
    "assert black_card_count != red_card_count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the probability that the first card will be red? Well, our card deck is biased, and the outcomes are not equally likely. Thus, a weighted sample space dictionary is required to compute the probability.\n",
    "\n",
    "**Listing 3. 35. Computing card probabilities using a sample space**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "weighted_sample_space = {'red_card': red_card_count,\n",
    "                         'black_card': black_card_count}\n",
    "prob_red = compute_event_probability(lambda x: x == 'red_card',\n",
    "                                     weighted_sample_space)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, we can easily show that the probability of drawing a red card is equal to `red_card_count` divided by `total_cards`.\n",
    "\n",
    "**Listing 3. 36. Computing card probabilities using division**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert prob_red == red_card_count / total_cards"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll utilize `prob_red` to model a flipped-over first card using the Binomial distribution.\n",
    "\n",
    "**Listing 3. 37. Simulating a random card**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first card in the shuffled deck is red\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "color = 'red' if np.random.binomial(1, prob_red) else 'black'\n",
    "print(f\"The first card in the shuffled deck is {color}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We’ll proceed to shuffle the deck 10 times, and flip over the first card after each shuffle.\n",
    "\n",
    "**Listing 3. 38. Simulating 10 random cards**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In 8 of out 10 shuffles, a red card came up first.\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "red_count = np.random.binomial(10, prob_red)\n",
    "print(f\"In {red_count} of out 10 shuffles, a red card came up first.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets now shuffle now shuffle the deck 50,000 times. Afterwards, lets compute the frequency and then re-do the shuffling procedure another 100,000 times. We use the resulting frequencies to compute a 95% confidence interval for flipping over a red card.\n",
    "\n",
    "**Listing 3. 39. Computing card-probability confidence intervals**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The frequency range 0.842865 - 0.849139 represents a 95.16% confidence interval\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "red_card_count_array = np.random.binomial(50000, prob_red, 100000) \n",
    "frequency_array = red_card_count_array / 50000\n",
    "\n",
    "likelihoods, bin_edges = np.histogram(frequency_array, bins='auto', \n",
    "                                      density=True)\n",
    "bin_width = bin_edges[1] - bin_edges[0]\n",
    "start_index, end_index = compute_high_confidence_interval(likelihoods, bin_width) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are highly confident that red_card_count lies between `0.842865 * total_cards` and `0.849139 *\n",
    "total_cards`. Let’s compute the likely range of `red_card_count`.\n",
    "\n",
    "**Listing 3. 40. Estimating the red card count**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of red cards in the deck is between 44 and 44\n"
     ]
    }
   ],
   "source": [
    "range_start = round(0.842865 * total_cards)\n",
    "range_end = round(0.849139 * total_cards)\n",
    "print(f\"The number of red cards in the deck is between {range_start} and {range_end}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are very confident that there are 44 red cards in the deck. Lets check if our solution is\n",
    "correct.\n",
    "\n",
    "**Listing 3. 41. Validating the red card count**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are correct! There are 44 red cards in the deck\n"
     ]
    }
   ],
   "source": [
    "if red_card_count == 44:\n",
    "    print('We are correct! There are 44 red cards in the deck')\n",
    "else:\n",
    "    print('Oops! Our sampling estimation was wrong.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4. Using Permutations to Shuffle Cards\n",
    "Card-shuffling requires us to randomly re-order the elements of a card-deck. That random\n",
    "re-ordering can be carried out using the `np.random.shuffle` method.\n",
    "\n",
    "**Listing 3. 42. Shuffling a 4-card deck**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "card_deck = [1, 1, 0, 0]\n",
    "np.random.shuffle(card_deck)\n",
    "print(card_deck)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we prefer to carry out the shuffle while retaining a copy of the original unshuffled deck, we can do so using\n",
    "`np.random.permutation`.\n",
    "\n",
    "**Listing 3. 43. Returning a copy of the shuffled deck**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 1 1]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "unshuffled_deck = [1, 1, 0, 0]\n",
    "shuffled_deck = np.random.permutation(unshuffled_deck)\n",
    "assert unshuffled_deck == [1, 1, 0, 0]\n",
    "print(shuffled_deck)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The random ordering of elements returned by `np.random.permutation` is mathematically called a **permutation**. Calling `itertools.permutations(unshuffled_deck)` will return an iterable over every possible permutation of the deck.\n",
    "\n",
    "**Listing 3. 44. Iterating over card permutations**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 0, 0)\n",
      "(1, 1, 0, 0)\n",
      "(1, 0, 1, 0)\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "for permutation in list(itertools.permutations(unshuffled_deck))[:3]:\n",
    "    print(permutation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first 2 generated permutations are identical to each other, because identical zeros were swapped by the `permutation` function. We can confirm the swap actually took place by examining the first\n",
    "three permutations of `[0, 1, 2, 3]`.\n",
    "\n",
    "**Listing 3. 45. Monitoring permutation swaps**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 1, 2, 3)\n",
      "(0, 1, 3, 2)\n",
      "(0, 2, 1, 3)\n"
     ]
    }
   ],
   "source": [
    "for permutation in list(itertools.permutations([0, 1, 2, 3]))[:3]:\n",
    "    print(permutation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Certain permutations of the 4-card deck occur more than once.  Let’s store these permutation counts within a `weighted_sample_space` dictionary.\n",
    "\n",
    "**Listing 3. 46. Computing permutation counts**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Permutation (1, 1, 0, 0) occurs 4 times\n",
      "Permutation (1, 0, 1, 0) occurs 4 times\n",
      "Permutation (1, 0, 0, 1) occurs 4 times\n",
      "Permutation (0, 1, 1, 0) occurs 4 times\n",
      "Permutation (0, 1, 0, 1) occurs 4 times\n",
      "Permutation (0, 0, 1, 1) occurs 4 times\n"
     ]
    }
   ],
   "source": [
    "weighted_sample_space = defaultdict(int)\n",
    "for permutation in itertools.permutations(unshuffled_deck):\n",
    "    weighted_sample_space[permutation] += 1\n",
    "\n",
    "for permutation, count in weighted_sample_space.items():\n",
    "    print(f\"Permutation {permutation} occurs {count} times\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the permutations occur with equal frequency. Consequently, an unweighted sample space should be sufficient to compute permutation probabilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability that a shuffle does not alter the deck is 0.16666666666666666\n"
     ]
    }
   ],
   "source": [
    "sample_space = set(itertools.permutations(unshuffled_deck)) \n",
    "event_condition = lambda x: list(x) == unshuffled_deck \n",
    "prob = compute_event_probability(event_condition, sample_space) \n",
    "assert prob == 1 / len(sample_space)\n",
    "print(f\"Probability that a shuffle does not alter the deck is {prob}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compute probabilities directly from the unweighted sample. Unfortunately, creating this sample space is not feasible for a deck of 52 cards. However, such a sample space could easily be computed for smaller deck of size 10.\n",
    "\n",
    "**Listing 3. 48. Computing a 10-card sample space**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample space for a 10-card deck contains 252 elements\n"
     ]
    }
   ],
   "source": [
    "red_cards = 5 * [1]\n",
    "black_cards = 5 * [0]\n",
    "unshuffled_deck = red_cards + black_cards\n",
    "sample_space = set(itertools.permutations(unshuffled_deck))\n",
    "print(f\"Sample space for a 10-card deck contains {len(sample_space)} elements\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Case Study 1 Solution\n",
    "##  4.1. Overview\n",
    "Our aim is to play a card-game in which the cards are iteratively flipped until we tell the\n",
    "dealer to stop. Afterwards, one additional card is flipped. If that card is red, we win a dollar.\n",
    "Otherwise, we lose a dollar.\n",
    "\n",
    "## 4.2. Predicting Red Cards within a Shuffled Deck\n",
    "We’ll start by creating a deck holding 26 red cards and 26 black cards. Black cards are\n",
    "represented by zeroes and red cards are represented by ones.\n",
    "\n",
    "**Listing 4. 1. Modeling a 52-card deck**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "red_cards = 26 * [1]\n",
    "black_cards = 26 * [0]\n",
    "unshuffled_deck = red_cards + black_cards"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We’ll proceed to shuffle the deck.\n",
    "\n",
    "**Listing 4. 2. Shuffling a 52-card deck**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(1)\n",
    "shuffled_deck = np.random.permutation(unshuffled_deck)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we’ll iteratively flip over the cards within the deck, stopping when the the number of red cards remaining in the deck is greater than the number of black cards remaining in the deck.\n",
    "\n",
    "**Listing 4. 3. Coding a card-game strategy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping the game at index 0.\n",
      "The next card in the deck is red.\n",
      "We have won!\n"
     ]
    }
   ],
   "source": [
    "remaining_red_cards = 26\n",
    "for i, card in enumerate(shuffled_deck[:-1]):\n",
    "    remaining_red_cards -= card\n",
    "    remaining_total_cards = 52 - i - 1\n",
    "    if remaining_red_cards / remaining_total_cards > 0.5:\n",
    "        break\n",
    "\n",
    "print(f\"Stopping the game at index {i}.\")\n",
    "final_card = shuffled_deck[i + 1]\n",
    "color = 'red' if final_card else 0\n",
    "print(f\"The next card in the deck is {'red' if final_card else 'black'}.\")\n",
    "print(f\"We have {'won' if final_card else 'lost'}!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The strategy yielded a win on our very first try. Lets generalize this strategy to halt when the\n",
    "fraction of remaining red cards is greater than an inputted `min_red_fraction` parameter.\n",
    "\n",
    "**Listing 4. 4. Generalizing the card-game strategy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_cards = 52\n",
    "total_red_cards = 26\n",
    "def execute_strategy(min_fraction_red=0.5, shuffled_deck=None,\n",
    "                     return_index=False):\n",
    "    if shuffled_deck is None:\n",
    "        shuffled_deck = np.random.permutation(unshuffled_deck) \n",
    "        \n",
    "    remaining_red_cards = total_red_cards\n",
    "\n",
    "    for i, card in enumerate(shuffled_deck[:-1]):\n",
    "        remaining_red_cards -= card\n",
    "        fraction_red_cards = remaining_red_cards / (total_cards - i - 1)\n",
    "        if fraction_red_cards > min_fraction_red:\n",
    "            break\n",
    "            \n",
    "    return (i+1, shuffled_deck[i+1]) if return_index else shuffled_deck[i+1] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.1. Estimating the Probability of Strategy Success\n",
    "Lets apply our basic strategy to a series of 1000 random shuffles.\n",
    "\n",
    "**Listing 4. 5. Running strategy over 1000 shuffles**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "observations = np.array([execute_strategy() for _ in range(1000)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The total fraction of ones in observations corresponds to the observed fraction of red cards, and therefore to the fraction of wins. We can compute this fraction by calling `observations.mean()`.\n",
    "\n",
    "**Listing 4. 6. Computing the frequency of wins**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The frequency of wins is 0.511\n"
     ]
    }
   ],
   "source": [
    "frequency_wins = observations.sum() / 1000\n",
    "assert frequency_wins == observations.mean()\n",
    "print(f\"The frequency of wins is {frequency_wins}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We’ve won 51.1 percent of total games! Our strategy appears to be working. 524 wins and 76 losses will net us a total profit of $22.\n",
    "\n",
    "**Listing 4. 7. Computing total profit**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total profit is $22.0\n"
     ]
    }
   ],
   "source": [
    "dollars_won = frequency_wins * 1000\n",
    "dollars_lost = (1 - frequency_wins) * 1000\n",
    "total_profit = dollars_won - dollars_lost\n",
    "print(f\"Total profit is ${total_profit}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The strategy worked well for a sample size of 1000 shuffles. We’ll now plot the strategy’s\n",
    "win-frequency convergence over a series of sample sizes ranging from 1 to 10,000.\n",
    "\n",
    "**Listing 4. 8. Plotting simulated frequencies of wins**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The win-frequency for 10,000 shuffles is 0.5035035035035035\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "def repeat_game(number_repeats):\n",
    "    observations = np.array([execute_strategy()\n",
    "                             for _ in range(number_repeats)])\n",
    "    return observations.mean()\n",
    "\n",
    "frequencies = []\n",
    "for i in range(1, 1000):\n",
    "    frequencies.append(repeat_game(i))\n",
    "\n",
    "plt.plot(list(range(1, 1000)), frequencies)\n",
    "plt.axhline(0.5, color='k')\n",
    "plt.xlabel('Number of Card Shuffles')\n",
    "plt.ylabel('Win-Frequency')\n",
    "plt.show()\n",
    "print(f\"The win-frequency for 10,000 shuffles is {frequencies[-1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our strategy fluctuates above and below 50% through-out the entire sampling process. We'll need to compute a confidence interval to ensure that its win-rate is above 50%. We’ll compute the confidence interval by sampling 10,000 card-shuffles 300 times. Shuffling an array is a computationally expensive procedure. **The code below will take approximately 40 seconds to run. Hence, it has been commented out.**\n",
    "\n",
    "**Listing 4. 9. Computing the confidence interval for 3 million shuffles**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nnp.random.seed(0)\\nfrequency_array = np.array([repeat_game(10000) for _ in range(300)])\\n\\nlikelihoods, bin_edges, patches = plt.hist(frequency_array, bins='auto',\\n                                           edgecolor='black', density=True)\\nbin_width = bin_edges[1] - bin_edges[0]\\nstart_index, end_index = compute_high_confidence_interval(likelihoods, bin_width)\\n\\nfor i in range(start_index, end_index):\\n     patches[i].set_facecolor('yellow')\\nplt.xlabel('Binned Frequency')\\nplt.ylabel('Relative Likelihood')\\nplt.show()\\n\""
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "np.random.seed(0)\n",
    "frequency_array = np.array([repeat_game(10000) for _ in range(300)])\n",
    "\n",
    "likelihoods, bin_edges, patches = plt.hist(frequency_array, bins='auto',\n",
    "                                           edgecolor='black', density=True)\n",
    "bin_width = bin_edges[1] - bin_edges[0]\n",
    "start_index, end_index = compute_high_confidence_interval(likelihoods, bin_width)\n",
    "\n",
    "for i in range(start_index, end_index):\n",
    "     patches[i].set_facecolor('yellow')\n",
    "plt.xlabel('Binned Frequency')\n",
    "plt.ylabel('Relative Likelihood')\n",
    "plt.show()\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can narrow the confidence interval by increasing the sample size, at the expense of running time. The code below will sample 50,000 shuffles over 3,000 iterations. **The code will take approximately one hour to run. Hence, it has been commented out.**\n",
    "\n",
    "**Listing 4. 10. Computing the confidence interval for 150 million shuffles**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nnp.random.seed(0)\\n\\nfrequency_array = np.array([repeat_game(50000) for _ in range(3000)])\\nlikelihoods, bin_edges = np.histogram(frequency_array, bins='auto',\\n                                      density=True)\\nbin_width = bin_edges[1] - bin_edges[0]\\ncompute_high_confidence_interval(likelihoods, bin_width)\\n\""
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "np.random.seed(0)\n",
    "\n",
    "frequency_array = np.array([repeat_game(50000) for _ in range(3000)])\n",
    "likelihoods, bin_edges = np.histogram(frequency_array, bins='auto',\n",
    "                                      density=True)\n",
    "bin_width = bin_edges[1] - bin_edges[0]\n",
    "compute_high_confidence_interval(likelihoods, bin_width)\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also `min_red_fraction` from 0.5 to 0.75 and repeat the confidence interval calculation process. **As before, the code will take approximately one hour to run. Hence, it has been commented out.**\n",
    "\n",
    "**Listing 4. 11. Computing the confidence interval for an updated strategy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nnp.random.seed(0)\\ndef repeat_game(number_repeats, min_red_fraction):\\n    observations = np.array([execute_strategy(min_red_fraction)\\n                            for _ in range(number_repeats)])\\n    return observations.mean()\\n\\nfrequency_array = np.array([repeat_game(50000, 0.75) for _ in range(3000)])\\nlikelihoods, bin_edges = np.histogram(frequency_array, bins='auto',\\n                                      density=True)\\nbin_width = bin_edges[1] - bin_edges[0]\\ncompute_high_confidence_interval(likelihoods, bin_width)\\n\""
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "np.random.seed(0)\n",
    "def repeat_game(number_repeats, min_red_fraction):\n",
    "    observations = np.array([execute_strategy(min_red_fraction)\n",
    "                            for _ in range(number_repeats)])\n",
    "    return observations.mean()\n",
    "\n",
    "frequency_array = np.array([repeat_game(50000, 0.75) for _ in range(3000)])\n",
    "likelihoods, bin_edges = np.histogram(frequency_array, bins='auto',\n",
    "                                      density=True)\n",
    "bin_width = bin_edges[1] - bin_edges[0]\n",
    "compute_high_confidence_interval(likelihoods, bin_width)\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3. Optimizing Strategies using the Sample Space for a 10-Card Deck\n",
    "The code below computes the sample space for a 10-card deck. Afterwards, it applies our\n",
    "basic strategy to that sample space. Its output is the probability of a win.\n",
    "\n",
    "**Listing 4. 12. Applying a basic strategy to a 10-card deck**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability of a win is 0.5\n"
     ]
    }
   ],
   "source": [
    "total_cards = 10\n",
    "total_red_cards = int(total_cards / 2)\n",
    "total_black_cards = total_red_cards\n",
    "unshuffled_deck = [1] * total_red_cards + [0] * total_black_cards\n",
    "sample_space = set(itertools.permutations(unshuffled_deck))\n",
    "win_condition = lambda x: execute_strategy(shuffled_deck=np.array(x)) \n",
    "prob_win = compute_event_probability(win_condition, sample_space)\n",
    "print(f\"Probability of a win is {prob_win}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Surprisingly, our basic strategy yields a win only 50% of the time. Lets compute the win-probabilities over a range\n",
    "of min_red_fraction values.\n",
    "\n",
    "**Listing 4. 13. Applying multiple strategies to a 10-card deck**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lowest probability of win is 0.5\n",
      "Highest probability of win is 0.5\n"
     ]
    }
   ],
   "source": [
    "def scan_strategies():\n",
    "    fractions = [value / 100 for value in range(50, 100)]\n",
    "    probabilities = []\n",
    "    for frac in fractions:\n",
    "        win_condition = lambda x: execute_strategy(frac,\n",
    "                                                   shuffled_deck=np.array(x))\n",
    "        probabilities.append(compute_event_probability(win_condition,\n",
    "                                                       sample_space))\n",
    "    return probabilities\n",
    "\n",
    "probabilities = scan_strategies()\n",
    "print(f\"Lowest probability of win is {min(probabilities)}\")\n",
    "print(f\"Highest probability of win is {max(probabilities)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both the lowest and highest probabilities are equal to 0.5! Perhaps adjusting the deck size will yield some\n",
    "improvement. Let’s analyze the sample spaces of decks containing 2, 4, 6, and 8 cards.\n",
    "\n",
    "**Listing 4. 14. Applying multiple strategies to multiple decks**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No winning strategy found for deck of size 2\n",
      "No winning strategy found for deck of size 4\n",
      "No winning strategy found for deck of size 6\n",
      "No winning strategy found for deck of size 8\n"
     ]
    }
   ],
   "source": [
    "for total_cards in [2, 4, 6, 8]:\n",
    "    total_red_cards = int(total_cards / 2)\n",
    "    total_black_cards = total_red_cards\n",
    "    unshuffled_deck = [1] * total_red_cards + [0] * total_black_cards\n",
    "\n",
    "    sample_space = set(itertools.permutations(unshuffled_deck))\n",
    "    probabilities = scan_strategies()\n",
    "    if all(prob == 0.5 for prob in probabilities):\n",
    "        print(f\"No winning strategy found for deck of size {total_cards}\")\n",
    "    else:\n",
    "        print(f\"Winning strategy found for deck of size {total_cards}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All of the strategies yield a probability of 0.5 across the small decks. Our strategies don’t work on a 10-card deck, and we have little reason to believe that they will work on a 52-card deck. To better understand why this is the case, we can re-run our simulations over a 52 card deck while plotting wins and losses relative to halting and non-halting scenarios.\n",
    "\n",
    "**Listing 4. 15. Plotting strategy outcomes across a 52-card deck**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "total_cards = 52\n",
    "total_red_cards = 26\n",
    "unshuffled_deck = red_cards + black_cards\n",
    "\n",
    "def repeat_game_detailed(number_repeats, min_red_fraction):\n",
    "\n",
    "    observations = [execute_strategy(min_red_fraction, return_index=True)\n",
    "                    for _ in range(num_repeats)] \n",
    "    successes = [index for index, card, in observations if card == 1] \n",
    "    halt_success = len([index for index in successes if index != 51]) \n",
    "    no_halt_success = len(successes) - halt_success \n",
    "\n",
    "    failures = [index for index, card, in observations if card == 0] \n",
    "    halt_failure = len([index for index in failures if index != 51]) \n",
    "    no_halt_failure = len(failures) - halt_failure \n",
    "    result = [halt_success, halt_failure, no_halt_success, no_halt_failure]\n",
    "    return [r / number_repeats for r in result] \n",
    "\n",
    "fractions = [value / 100 for value in range(50, 100)]\n",
    "num_repeats = 50000\n",
    "result_types = [[], [], [], []]\n",
    "\n",
    "for fraction in fractions: \n",
    "    result = repeat_game_detailed(num_repeats, fraction)\n",
    "    for i in range(4):\n",
    "        result_types[i].append(result[i])\n",
    "\n",
    "plt.plot(fractions, result_types[0],\n",
    "         label='A) Strategy Halts. We Win.')\n",
    "plt.plot(fractions, result_types[1], linestyle='--',\n",
    "         label='B) Strategy Halts. We Lose.')\n",
    "plt.plot(fractions, result_types[2], linestyle=':',\n",
    "         label='C) No Halt. We Win.')\n",
    "plt.plot(fractions, result_types[3], linestyle='-.',\n",
    "         label='D) No Halt. We Lose.')\n",
    "plt.xlabel('min_red_fraction')\n",
    "plt.ylabel('Frequency')\n",
    "plt.legend(bbox_to_anchor=(0.25, 1.0))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The added frequencies of Scenarios A and B appear to fluctuate at around 0.5. No matter what we do, our likelihood of winning remains 50-50. Therefore, the most optimal strategy we can offer is to pick the first card in the shuffled deck.\n",
    "\n",
    "**Listing 4. 16. The most optimal winning strategy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimal_strategy(shuffled_deck):\n",
    "    return shuffled_deck[0]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
